home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / et / src / setup.c < prev    next >
Text File  |  1993-07-08  |  13KB  |  554 lines
  1. #include  "et.h"
  2. int   set_max()/*et*/
  3. {
  4.   int   i, i_b, z_max;
  5.   
  6.   i = i_b = 0;
  7.   z_max = (G_pm.i.dist - G_pm.i.pers) * GETA_ET;
  8.   do {
  9.     if (z_max < G_mv[i].z) {
  10.       z_max = G_mv[i].z;
  11.       i_b = i;
  12.     }
  13.   } while (G_mv[i++].key != EOK);
  14.   return(i_b);
  15. }
  16. int   set_min()/*et*/
  17. {
  18.   int   i, i_b, z_min;
  19.   
  20.   i = i_b = 0;
  21.   z_min = (G_pm.i.dist - G_pm.i.pers) * GETA_ET;
  22.   do {
  23.     if (z_min > G_mv[i].z) {
  24.       z_min = G_mv[i].z;
  25.       i_b = i;
  26.     }
  27.   } while (G_mv[i++].key != EOK);
  28.   return(i_b);
  29. }
  30. void  set_ww(int menu_i)/*et*/
  31. {
  32.   int   cut, r_b, mm, key_i, key_b, max_i, min_i, max_b, min_b, r_d, z_d;;
  33.   
  34.   disp_menu(menu_i, P_v[v_VIEW_0], 5, 0);
  35.   set_bit(G_f, f_RR);
  36.   save_key(-1);
  37.   r_b = G_pm.i.r;
  38.   key_i = 0;
  39.   do {
  40.     G_mv[key_i].r = r_b;
  41.   } while (G_mv[key_i++].key != EOK);
  42.   do {
  43.     max_i = set_max();
  44.     key_b = G_mv[max_i].key;
  45.     G_mv[max_i].key = EOK;
  46.     mm = (max_i) ? 7 : 0;
  47.     key_i = 0;
  48.     go_bar(&key_i, mm, 0);
  49.     G_pm.i.r = G_mv[max_i].r;
  50.     draw_pm(menu_i, H_WHT);
  51.     if (!mm)
  52.       draw_edge(P_SET, AFT);
  53.     copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, PEEK);
  54.     exchange_page();
  55.     copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, POKE);
  56.     exchange_page();
  57.     change(mn_WW);
  58.     max_b = G_pm.i.r;
  59.     G_mv[max_i].key = key_b;
  60.     min_i = set_min();
  61.     key_b = G_mv[min_i].key;
  62.     G_mv[min_i].key = EOK;
  63.     mm = (min_i) ? 7 : 0;
  64.     key_i = 0;
  65.     go_bar(&key_i, mm, 0);
  66.     G_pm.i.r = G_mv[min_i].r;
  67.     draw_pm(menu_i, H_WHT);
  68.     if (!mm)
  69.       draw_edge(P_SET, AFT);
  70.     copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, PEEK);
  71.     exchange_page();
  72.     copy_window(P_i[i_WIN_VRAM], P_v[v_VRAM], 0x14, POKE);
  73.     exchange_page();
  74.     change(mn_WW);
  75.     min_b = G_pm.i.r;
  76.     G_mv[min_i].key = key_b;
  77.     G_mv[max_i].r = max_b;
  78.     G_mv[min_i].r = min_b;
  79.     if (max_i != min_i) {
  80.       r_d = G_mv[max_i].r - G_mv[min_i].r;
  81.       z_d = G_mv[max_i].z - G_mv[min_i].z;
  82.       cul_r(max_i, min_i, r_d, z_d);
  83.     }
  84.     key_i = 0;
  85.     cut = go_bar(&key_i, 0, 0);
  86.   } while (cut == _ESC);
  87.   mm = 4;
  88.   if (!cut) 
  89.     draw_edge(P_SET, AFT);
  90.   else {
  91.     while (cut) {
  92.       if (mm == 4)
  93.         draw_edge(P_RES, AFT);
  94.       cut = go_bar(&key_i, mm, 0);
  95.       draw_edge(P_SET, AFT);
  96.       mm = (mm == 4) ? 2 : 4;
  97.     }
  98.   }
  99.   G_pm.i.r = min_b;
  100.   disp_menu(menu_i, P_v[v_VIEW_0], 6, 0);
  101. }
  102. void  set_et_rr_col(int *col_p, int *col2_p, int *line_m_p, int mm, int ii)/*et*/
  103. {
  104.   int   i;
  105.   
  106.   if (!test_bit(G_f, f_TT|f_EE|f_GPH)) {
  107.     if (test_bit(G_f, f_AA))
  108.       *col_p = (ii == ENT) ? H_RED : H_WHT;
  109.     else if (test_bit(G_f, f_TROFF))
  110.       *col_p = H_MZN;
  111.     else
  112.       *col_p = H_RED;
  113.     *line_m_p = (test_bit(G_f, f_AA) || ii == ENT) ? P_SET : P_NEG;
  114.   } else if (test_bit(G_f, f_SV) && !test_bit(G_f, f_GPH)) {
  115.     if (test_bit(G_f, f_TT))
  116.       if (test_bit(G_f, f_EE)) {
  117.         *col_p = H_RED;
  118.         *col2_p = H_SYN;
  119.         *line_m_p = P_SET;
  120.       } else {
  121.         *col_p = H_SYN;
  122.         *col2_p = 0;
  123.         *line_m_p = P_SET;
  124.       }
  125.     else {
  126.       i = test_bit(G_f, f_AA|f_NN);
  127.       *col2_p = 0;
  128.       switch(i) {
  129.       case 0:
  130.         *col_p = H_RED;
  131.         *col2_p = H_GRN;
  132.         *line_m_p = P_SET;
  133.         break;
  134.       case f_AA:
  135.         *col_p = H_RED;
  136.         *col2_p = H_WHT;
  137.         *line_m_p = P_SET;
  138.         break;
  139.       case f_NN:
  140.         *col_p = L_GRN;
  141.         *line_m_p = P_RES;
  142.         break;
  143.       }
  144.     }
  145.   } else if (test_bit(G_f, f_GPH)) {
  146.     if (!test_bit(G_f, f_EE)) {
  147.       *col_p = (mm == _LT) ? H_BLU : H_RED;
  148.       *line_m_p = (test_bit(G_f, f_AA) || ii == ENT) ? P_SET : P_NEG;
  149.     } else
  150.       if (test_bit(G_f, f_TT)) {
  151.         if (test_bit(G_f, f_EE)) {
  152.           *col_p = (mm == _LT) ? L_BLU : L_RED;
  153.           *col2_p = (mm == _LT) ? H_BLU : H_RED;
  154.           *line_m_p = P_SET;
  155.         } else {
  156.           *col_p = (mm == _LT) ? H_BLU : H_RED;
  157.           *col2_p = 0;
  158.           *line_m_p = P_SET;
  159.         }
  160.       } else {
  161.         i = test_bit(G_f, (f_AA|f_NN));
  162.         *col2_p = 0;
  163.         switch(i) {
  164.         case 0:
  165.           *col_p = (mm == _LT) ? L_BLU : L_RED;
  166.           *col2_p = (mm == _LT) ? H_BLU : H_RED;
  167.           *line_m_p = P_SET;
  168.           break;
  169.         case f_AA:
  170.           *col_p = (mm == _LT) ? L_BLU : L_RED;
  171.           *col2_p = (mm == _LT) ? H_BLU : H_RED;
  172.           *line_m_p = P_SET;
  173.           break;
  174.         case f_NN:
  175.           *col_p = H_BLK;
  176.           *line_m_p = P_RES;
  177.           break;
  178.         }
  179.       }
  180.   } else
  181.     if (test_bit(G_f, f_TT)) {
  182.       if (test_bit(G_f, f_EE)) {
  183.         *col_p = H_RED;
  184.         *col2_p = H_SYN;
  185.         *line_m_p = P_SET;
  186.       } else {
  187.         *col_p = H_SYN;
  188.         *col2_p = 0;
  189.         *line_m_p = P_SET;
  190.       }
  191.     } else {
  192.       i = test_bit(G_f, (f_AA|f_NN));
  193.       *col2_p = 0;
  194.       switch(i) {
  195.       case 0:
  196.         *col_p = H_RED;
  197.         *col2_p = H_GRN;
  198.         *line_m_p = P_SET;
  199.         break;
  200.       case f_AA:
  201.         *col_p = H_RED;
  202.         *col2_p = H_WHT;
  203.         *line_m_p = P_SET;
  204.         break;
  205.       case f_NN:
  206.         *col_p = L_GRN;
  207.         *line_m_p = P_RES;
  208.         break;
  209.       }
  210.     }
  211. }
  212. void  cls_view(int *pq_p)/*et*/
  213. {
  214.   int   i;
  215.   VRAM  *vram;
  216.   
  217.   i = (pq_p == P_i[i_WIN_VRAM]) ? VRAM_SIZE : VIEW_SIZE;
  218.   vram = P_v[v_VRAM];
  219.   while (i--)
  220.     *vram++ = 0;
  221.   copy_window(pq_p, P_v[v_VRAM], 0x14, POKE);
  222. }
  223. void  set_icn_pq(int pq_a[], int name_i, int zl)/*et*/
  224. {
  225.   int   pi, qi;
  226.   
  227.   pi = name_i % 8;
  228.   qi = name_i / 8;
  229.   pq_a[0] = P_i[i_WIN_VIEW][0] + P_i[i_SIZE_ICN][2] * 8 * pi + zl;
  230.   pq_a[1] = P_i[i_WIN_VIEW][1] + P_i[i_SIZE_ICN][3] * qi + zl;
  231.   pq_a[2] = pq_a[0] + P_i[i_SIZE_ICN][2] * 8 - 1 - zl;
  232.   pq_a[3] = pq_a[1] + P_i[i_SIZE_ICN][3] - 1 - zl;
  233. }
  234. void  set_font_pq(int pq_a[], int menu_i)/*et*/
  235. {
  236.   pq_a[0] = G_mn[menu_i].p+80+120-8+21;
  237.   pq_a[1] = G_mn[menu_i].q-1;
  238.   pq_a[2] = G_mn[menu_i].p+98+120-8+21;
  239.   pq_a[3] = G_mn[menu_i].q+17;
  240. }
  241. void  set_var_pq(int menu_i, int pq_a[])/*et*/
  242. {
  243.   if (menu_i == mn_FF) {
  244.     pq_a[0] = 580;
  245.     pq_a[1] = G_mn[menu_i].q;
  246.     pq_a[2] = pq_a[0]+8*4;
  247.     pq_a[3] = pq_a[1]+15;   /* 16 以上 は NG (^^; */
  248.   } else {
  249.     pq_a[0] = G_mn[menu_i].p+9*8+4;
  250.     pq_a[1] = G_mn[menu_i].q;
  251.     pq_a[2] = pq_a[0]+6*8;
  252.     pq_a[3] = pq_a[1]+16;
  253.   }
  254. }
  255. void  set_name_pq(int menu_i, int pq_a[])/*et*/
  256. {
  257.   pq_a[0] = G_mn[menu_i].p+(G_mn[menu_i].len+1)*8-4;
  258.   pq_a[1] = G_mn[menu_i].q-1;
  259.   pq_a[2] = pq_a[0]+(strlen(G_mn[menu_i].s)-G_mn[menu_i].len)*8-3;
  260.   pq_a[3] = pq_a[1]+17;
  261. }
  262. int   read_key(void)/*et*/
  263. {
  264.   int   i, key;
  265.   static int  add, shift;
  266.  
  267.   asm volatile ("
  268.     movb  $0x09,%%ah
  269.     movb  $0x01,%%al
  270.     int   $0x90
  271.     cmpb  $0xff,%%dh
  272.     jne   0f
  273.     movl  $%0,%%eax
  274.     movl  $0,(%%eax)
  275.     jmp   1f
  276.     .align  4
  277.   0:
  278.     movsbl  %%bh,%%ecx
  279.     movl  $%0,%%eax
  280.     movl  %%ecx,(%%eax)
  281.     movsbl  %%bl,%%ecx
  282.     movl  $%1,%%eax
  283.     movl  %%ecx,(%%eax)
  284.   1:
  285.     "
  286.     :
  287.     : "g"(add),"g"(shift)
  288.     : "bx"
  289.   );
  290. /*
  291.   regs.h.ah = 0x09;
  292.   regs.h.al = 0x01;
  293.   intreal(0x90, ®s, ®s, &segs);
  294.   if (regs.h.dh == 0xff)
  295.     add = 0;
  296.   else {
  297.     add = regs.h.bh;
  298.     shift = regs.h.bl;
  299.   }
  300. */
  301.   if (!add || (i = instring(add, P_c[c_ADD_KEY], sizeof(char))) == 0)
  302.     return(0);
  303.   key = P_c[c_KEY_0][i-1];
  304.   if (test_bit(shift, 0x14) == 0x14)
  305.     key += _SHIFT_CTRL-_KEY;
  306.   else if (test_bit(shift, 0x04))
  307.     key += _SHIFT-_KEY;
  308.   else if (test_bit(shift, 0x10))
  309.     key += _CTRL-_KEY;
  310.   switch(key) {
  311.   case S_C_LT:
  312.     if (G_nb.mouse)
  313.       G_nb.mouse--;
  314.     break;
  315.   case S_C_RT:
  316.     if (G_nb.mouse < MAX_MOUSE)
  317.       G_nb.mouse++;
  318.     break;
  319.   default:
  320.     break;
  321.   }
  322.   if (!test_bit(G_f, f_DEMO|f_MAKE|f_REPLAY) && !find_key(key))
  323.     key = 0;
  324.   return(key);
  325. }
  326. int   chk_trace_mode(int menu_i)/*et*/
  327. {
  328.   if (test_bit(G_f, f_AA))
  329.     return(menu_i);
  330.   else if (test_bit(G_f, f_NN))
  331.     return(menu_i+1);
  332.   else
  333.     return(menu_i+2);
  334. }
  335. int   set_nb_menu()/*et*/
  336. {
  337.   int   key_i, menu_i;
  338.   
  339.   key_i = nb_key(G_mv);
  340.   if (!key_i)
  341.     menu_i = chk_trace_mode(mn_MN_DEL_AA);
  342.   else if (key_i >= MAX_KEY) {
  343.     menu_i = chk_trace_mode(mn_MN_AREA_AA);
  344.     if (!test_bit(G_f, f_AREA))
  345.       set_bit(G_f, f_AREA);
  346.   } else {
  347.     menu_i = chk_trace_mode(mn_MN_AA);
  348.     if (test_bit(G_f, f_AREA))
  349.       res_bit(G_f, f_AREA);
  350.   }
  351.   return(menu_i);
  352. }
  353. void  set_replay(int n)/*et*/
  354. {
  355.   int   i, j;
  356.   FILE  *File, *Temp;
  357.   char  cp[1];
  358.   
  359.   File = fopen(P_c[c_FILE_REPLAY], "rb");
  360.   fseek(File, 0L, 2);
  361.   i = ftell(File);
  362.   j = i - n;
  363.   fseek(File, -j, 2);
  364.   Temp = et_fopen(P_c[c_FILE_ET_TEMP], "wb", NULL);
  365.   G_nb.drive = *P_c[c_FILE_ET_TEMP];
  366.   copy_file(Temp, File, j);
  367.   fclose(Temp);
  368.   fclose(File);
  369.   G_nb.replay = 0;  /* P_c[c_FILE_ET_TEMP] の先頭に */
  370. }
  371. void  init_et(void)/*et*/
  372. {
  373.   int   i, j;
  374.   DIR   Dir[1];
  375.  
  376.   init_pm();
  377.   init_key(0);
  378.   _set_break_off();
  379.   G_nb.page = 0;
  380.   display_page(G_nb.page);
  381.   G_vi.xo = P_i[i_SIZE_VIEW][2]+8;
  382.   G_vi.yo = P_i[i_SIZE_VIEW][3]+8;
  383.   G_vi.x = P_i[i_SIZE_VIEW][2];
  384.   G_vi.y = P_i[i_SIZE_VIEW][3];
  385.   G_nb.edge = G_nb.edge_b = nb_EDGE;
  386.   G_bf.dir = (DIR*)0x64000;
  387.   G_bf.pna = (DIR*)0x76000;
  388.   G_pn.pna = (char*)G_bf.pna;
  389.   Dir->next = NULL;
  390.   poke_dir(Dir, G_bf.dir);
  391.   Dir->dir = NULL;
  392.   poke_dir(Dir, G_bf.pna);
  393.   G_nb.pna_drive = G_nb.current;
  394.   for (i = 0; i < 30; i++)
  395.     P_i[i_PNA_N][i] = -1;
  396.   res_bit(G_f, f_AA|f_NN);
  397.   OUTPB(0xfda0, 4);
  398. }
  399. int   malloc_et()/*et*/
  400. {
  401.   int   i, max_edge;
  402.  
  403.   max_edge = 100;
  404.   while (1) {
  405.     G_bf.edge_buf = (char *)malloc(sizeof(EDGE) * max_edge);
  406.     G_et = (ET *)malloc(sizeof(ET) * max_edge);
  407.     G_edge = (EDGE *)malloc(sizeof(EDGE) * max_edge);
  408.     G_bf.edge = (EDGE *)malloc(sizeof(EDGE) * max_edge);
  409.     G_bf.et_buf = (char*)malloc(sizeof(EDGE) * max_edge*2);
  410.     i = G_et && G_edge && G_bf.edge && G_bf.et_buf && G_bf.edge_buf;
  411.     if (G_bf.edge_buf)
  412.       free(G_bf.edge_buf);
  413.     if (G_bf.et_buf)
  414.       free(G_bf.et_buf);
  415.     if (G_et)
  416.       free(G_et);
  417.     if (G_edge)
  418.       free(G_edge);
  419.     if (G_bf.edge)
  420.       free(G_bf.edge);
  421.     if (!i)
  422.       break;
  423.     max_edge += 100;
  424.   }
  425.   max_edge -= 100;
  426.   if (max_edge) {
  427.     G_et = (ET *)malloc((unsigned)sizeof(ET) * max_edge);
  428.     G_edge = (EDGE *)malloc((unsigned)sizeof(EDGE) * max_edge);
  429.     G_bf.edge = (EDGE *)malloc((unsigned)sizeof(EDGE) * max_edge);
  430.     G_bf.et_buf = (char*)malloc((unsigned)sizeof(EDGE) * max_edge*2);
  431.     G_bf.edge_buf = (char *)malloc((unsigned)sizeof(EDGE) * max_edge);
  432.   }
  433.   return(max_edge);
  434. }
  435. void  free_et(void)/*et*/
  436. {
  437.   if (G_bf.edge_buf)
  438.     free(G_bf.edge_buf);
  439.   if (G_bf.et_buf)
  440.     free(G_bf.et_buf);
  441.   if (G_et)
  442.     free(G_et);
  443.   if (G_edge)
  444.     free(G_edge);
  445.   if (G_bf.edge)
  446.     free(G_bf.edge);
  447. }
  448. void  term_et(void)/*et*/
  449. {
  450.   int   i;
  451.   
  452.   for (i = 2; i; i--, exchange_page()) {
  453.     cls_view(P_i[i_WIN_VRAM]);
  454.     if (i == 2) {
  455.       copy_window(P_i[i_WIN_VIEW], P_v[v_VIEW_0], 0x120, PEEK);
  456.       copy_window(P_i[i_WIN_VIEW], P_v[v_VIEW_1], 0x120, PEEK);
  457.     }
  458.   }
  459.   display_page(1);
  460.   OUTPB(0xfda0, 5);
  461.   init_key(1);
  462. }
  463. void  set_ent(char *xyz_p, int j)/*et*/
  464. {
  465.   int   i;
  466.   char  *c_p;
  467.   
  468.   c_p = (char*)((int)G_bf.et_buf + j * sizeof(ET));
  469.   for (i = sizeof(ET); i; i--)
  470.     *c_p++ = *xyz_p++;
  471. }
  472. int   set_key_col(void)/*et*/
  473. {
  474.   int   i;
  475.   
  476.   if (test_bit(G_f, f_AA))
  477.     i = H_WHT;
  478.   else if (test_bit(G_f, f_NN))
  479.     i = H_YEL;
  480.   else
  481.     i = H_GRN;
  482.   return(i);
  483. }
  484. int   set_csr_col(void)/*et*/
  485. {
  486.   int   i;
  487.   
  488.   if (test_bit(G_f, f_AA))
  489.     i = H_WHT;
  490.   else 
  491.     if (test_bit(G_f, f_TROFF))
  492.       i = H_MZN;
  493.     else
  494.       i = H_RED;
  495.   return(i);
  496. }
  497. void  set_file_i(char *file_p, int n)/*et*/
  498. {
  499.   int   i;
  500.   
  501.   for (i = 2; i; i--) {
  502.     *file_p-- = n % 10 + _00;
  503.     n /= 10;
  504.   }
  505. }
  506. char* shift_pna(char c_a[])/*et*/
  507. {
  508.   int   i;
  509.   char  *c_p;
  510.  
  511.   c_p = c_a;
  512.   do {
  513.     i = instring('\\', c_p, sizeof(char));
  514.     if (i)
  515.       c_p = &c_p[i];
  516.   } while (i);
  517.   return(c_p);
  518. }
  519. int   set_step(int v,int key)/*et*/
  520. {
  521.   int   i;
  522.   int   l;
  523.   
  524.   for (l = 1; v / l && l <= 10000L; l *= 10L)
  525.     ;
  526.   i = l / 10L;
  527.   switch(key) {
  528.   case _LT:
  529.     if (v < i+i/2)
  530.       i /= 10;
  531.     break;
  532.   case _RT:
  533.     if ((int)v+i > 30000)
  534.       i = 30000 - v;
  535.     break;
  536.   }
  537.   return(i);
  538. }
  539. void  set_xyz(int xyz_a[], int rxyz_a[], int mm)/*et*/
  540. {
  541.   int pos_x, pos_z;
  542.   
  543.   pos_x = G_ps.x;
  544.   pos_z = G_ps.z;
  545.   if (mm)
  546.     pos_z -= (int)(G_pm.i.dist - G_pm.i.pers) * GETA_ET;
  547.   xyz_a[0] = rxyz_a[0] + pos_x;
  548.   xyz_a[1] = rxyz_a[1] + pos_x;
  549.   xyz_a[2] = rxyz_a[2] + G_ps.y;
  550.   xyz_a[3] = rxyz_a[3] + G_ps.y;
  551.   xyz_a[4] = rxyz_a[4] + pos_z;
  552.   xyz_a[5] = rxyz_a[5] + pos_z;
  553. }
  554.